Automated troubleshooter

ABSTRACT

The technology described herein generates automated workflows from trouble shooting guides. The automated workflow generation process described herein starts with existing TSGs as the input. A first step in the process may be identifying the computer commands in the TSG. In one aspect, the commands are identified using a sequence-to-sequence model. Once a command is identified as a command, the command is associated with an application of origin. In aspects, a second model is used to identify the application associated with the command. The second model may be a metric-based meta-learning approach to associate a command with an application. Once the commands are identified and associated with an application, they may be parsed or extracted using a regular expression, which is a special text string describing a search pattern. The structure of the natural text is then parsed to build an executable decision tree and merged with the parsed commands.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application claims priority to India Application No. 202141028963, filed 28 Jun. 2021, and entitled, “AUTOMATED TROUBLESHOOTER.”

BACKGROUND

Incident management is a critical task performed by technical support teams, which may be responsible for timely acknowledgement and resolution of technical problems. The technical problems can be caused by an almost endless combination of software and hardware issues. Problems can be caused by software bugs, misconfiguration, user error, hardware failure, connection failures, and the like. Troubleshooting guides are a key resource for incident management and are used by support engineers for investigating and mitigating incidents. A key challenge with Troubleshooting guides is that they are fragmented, siloed, and may lack a consistent schema or structure. This prevents the automation of troubleshooting steps and workflows since they have to be manually parsed and executed by the support engineers. An organization's troubleshooting guides may be spread across multiple platforms (e.g., documents, notes, databases, and wikis) and cover many different types of software and hardware. Use of a troubleshooting guide by a support engineer requires a significant amount of domain and tribal knowledge.

SUMMARY

This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.

The technology described herein generates automated workflows from trouble shooting guides. The trouble-shooting guides are text documents that help a user identify and/or solve a problem. The automated workflow generation process described herein starts with existing TSGs as the input. The technology described herein converts the TSG from a manual that is followed by human users to an automated workflow that can be executed by a computer. The technology described herein also uses several technologies that efficiently build the automated workflow.

A first step in the process may be identifying the computer commands in the TSG. In one aspect, the commands are identified using a sequence-to-sequence model. In one aspect, training efficiency may be achieved by using transfer learning when training the model. In particular, an embedding layer may initiated with values from the trained embedding layer from the separate model used to classify commands by application of origin. Using these values as a starting point conserves computer resources by reducing aspects of the model that need to be trained.

Once a command is identified as a command, the command is associated with an application of origin. In aspects, a second model is used to identify the application associated with the command. The second model may be a metric-based meta-learning approach to associate a command with an application. The metric-based model calculates a metric or distance measure that can be used to determine similarity between commands. The meta-task can be—“Given a pair of commands, predict the probability that they belong to the same application.” The metric-learning model may be a twin neural network (sometimes called a Siamese neural network), which is an artificial neural network that uses two identical subnetworks.

Once the commands are identified and associated with an application, they may be parsed or extracted. A command may comprise multiple parts, such as command name, arguments, parameters, query attributes, flags, etc. These parts are parsed using regular expressions, which function as a type of query pattern to return the correct command part, such as command name. A regular expression (regex or regexp for short), is a special text string describing a search pattern. As can be seen, generating the large number of regular expressions needed to parse a large number of application commands would be labor intensive, if done manually. The regular expressions may be generated using program synthesis used in parsing commands. In one example, the MICROSOFT Prose tool is used to generate the regular expressions. Once the regular expressions are generated, they can be run.

The structure of the natural text is then parsed to build an executable decision tree and merged with the parsed commands. The result is an automated workflow that may be executed by a computing device to troubleshoot a problem.

BRIEF DESCRIPTION OF THE DRAWINGS

The technology described herein is illustrated by way of example and not limitation in the accompanying figures in which like reference numerals indicate similar elements and in which:

FIG. 1 is a block diagram of an example operating environment suitable for implementations of the present disclosure;

FIG. 2 is a diagram depicting an example automated troubleshooting system suitable for implementing aspects of the present disclosure;

FIG. 3 shows a twin neural network architecture for use classifying commands by application, in accordance with an aspect of the technology described herein;

FIG. 4 is a flowchart of a method for generating an automated troubleshooting workflow, in accordance with an aspect of the technology described herein;

FIG. 5 is a flowchart of a method for generating an automated troubleshooting workflow, in accordance with an aspect of the technology described herein;

FIG. 6 is a flowchart of a method for generating an automated troubleshooting workflow, in accordance with an aspect of the technology described herein;

FIG. 7 is a block diagram of an exemplary computing environment suitable for use in implementing aspects of the technology described herein.

DETAILED DESCRIPTION

The various technologies described herein are set forth with sufficient specificity to meet statutory requirements. However, the description itself is not intended to limit the scope of this patent. Rather, the inventors have contemplated that the claimed subject matter might also be embodied in other ways, to include different steps or combinations of steps similar to the ones described in this document, in conjunction with other present or future technologies. Moreover, although the terms “step” and/or “block” may be used herein to connote different elements of methods employed, the terms should not be interpreted as implying any particular order among or between various steps herein disclosed unless and except when the order of individual steps is explicitly described.

The technology described herein generates automated workflows from trouble shooting guides. The trouble-shooting guides are text documents that help a user identify and/or solve a problem. The automated workflow generation process described herein starts with existing TSGs as the input. The technology described herein converts the TSG that is followed by human users to an automated workflow that can be executed by a computer. A single TSG may include troubleshooting instructions for a large number of problems. The TSGs may include combinations of textual explanations for users and computer commands (e.g., application commands) to be run as part of a workflow. The text may instruct the user to run the command and explain how the command works. The commands may perform a large number of different tasks, such as retrieving information used to identify a problem's cause or eliminate a potential cause. The commands in a TSG may be from different applications (e.g., PowerShell, SQL, Kusto, Scope, CosmosDB). Even a troubleshooting workflow for a single problem may include commands from several different applications. TSGs include a complex series of steps that may take the form of a decision tree to arrive at a solution. A complex TSG may include multiple paths that may be followed until the troubleshooting is complete. The application commands may have multiple components, such as commands, arguments, parameters, and attributes.

A first step in the process may be identifying the computer commands in the TSG. The computer commands may be contrasted with the natural language text, which may explain how or when to use the command. Manually written Troubleshooting guides often contain a multitude of application commands for different applications along with natural language statements explaining their use. Commands may run over multiple lines and different types of commands can occur consecutively in the TSG without natural language text separating the commands. Thus, statements need to be segmented accurately to correctly identify, parse, and create automatable workflows. Attempting to parse two commands at once will increase the probability of an error. Similarly, attempting to parse a mixture of natural language text and a command will also increase the error probability.

In one aspect, the commands are identified using a sequence-to-sequence model. In one aspect, training efficiency may be achieved by using transfer learning when training the model. In particular, an embedding layer may be initiated with values from the trained embedding layer from the separate model used to classify commands by application of origin. Using these values as a starting point conserves computer resources by reducing aspects of the model that need to be trained.

Once a command is identified as a command, the command is associated with an application of origin. In aspects, a second model is used to identify the application associated with the command. The second model may be a metric-based meta-learning approach to associate a command with an application. The use of a metric-based meta-learning model can be trained for this task using a minimum amount training data, such as only one training example (one-shot) per application of origin. The use of a metric-based meta-learning can save computer resources by minimizing training iterations. The metric-based meta-learning also minimizes resources needed to collect and build training data examples.

The metric-based model calculates a metric or distance measure that can be used to determine similarity between commands. The meta-task can be—“Given a pair of commands, predict the probability that they belong to the same application.” The metric-learning model may be a twin neural network (sometimes called a Siamese neural network), which is an artificial neural network that uses two identical subnetworks. As used herein, “identical” means the two subnetworks having the same configuration with the same parameters and weights. Parameter updating is mirrored across both sub-networks during training.

Training the twin neural network comprises pairwise learning. Two labeled commands are input to the twin neural network and two feature vectors are generated. In some instances, the two commands are from the same application. In other instances, the two commands are from the different applications. Commands from the same application should result in similar feature vectors. The goal is to train the twin neural network to generate similar feature vectors when the commands are from the same application and different feature vectors when the commands are from different applications. In aspects, the training involves few-shot learning, which allows for efficient training of the neural network.

Once the commands are identified and associated with an application, they may be parsed or extracted. A command may comprise multiple parts, such as command name, arguments, parameters, query attributes, flags, etc. These parts are parsed using regular expressions, which function as a type of query pattern to return the correct command part, such as command name. A regular expression (regex or regexp for short), is a special text string describing a search pattern. As previously noted, each command is now associated with an application in which the command may be used. The regular expressions may be specific to each application. For example, the command name may follow a different format in each application. In this case, a specific regular expression may be generated to parse the command name in each application.

As can be seen, generating the large number of regular expressions needed to parse a large number of application commands would be labor intensive, if done manually. Program synthesis may be used to generate regular expressions used in parsing commands. The use of program synthesis to generate regular expressions can save considerable time and resources compared to other methods. In one example, the MICROSOFT Prose tool is used to generate the regular expressions. Once the regular expressions are generated, they can be run.

The structure of the natural text is then parsed to build an executable decision tree and merged with the parsed commands. The result is an automated workflow that may be executed by a computing device to troubleshoot a problem.

Having briefly described an overview of aspects of the technology described herein, an exemplary operating environment in which aspects of the technology described herein may be implemented is described below in order to provide a general context for various aspects.

Turning now to FIG. 1 , a block diagram is provided showing an example operating environment 100 in which some aspects of the present disclosure may be employed. It should be understood that this and other arrangements described herein are set forth only as examples. Other arrangements and elements (e.g., machines, interfaces, functions, orders, and groupings of functions, etc.) may be used in addition to or instead of those shown, and some elements may be omitted altogether for the sake of clarity. Further, many of the elements described herein are functional entities that may be implemented as discrete or distributed components or in conjunction with other components, and in any suitable combination and location. Various functions described herein as being performed by one or more entities may be carried out by hardware, firmware, and/or software. For instance, some functions may be carried out by a processor executing instructions stored in memory.

Among other components not shown, example operating environment 100 includes a number of user devices, such as user devices 102 a and 102 b through 102 n; a number of data sources, such as data sources 104 a and 104 b through 104 n; server 106; and network 110. Each of the components shown in FIG. 1 may be implemented via any type of computing device, such as computing device 700 described in connection to FIG. 7 , for example. These components may communicate with each other via network 110, which may include, without limitation, one or more local area networks (LANs) and/or wide area networks (WANs). In exemplary implementations, network 110 comprises the Internet and/or a cellular network, amongst any of a variety of possible public and/or private networks.

User devices 102 a and 102 b through 102 n may be client devices on the client-side of operating environment 100, while server 106 may be on the server-side of operating environment 100. The user devices may facilitate generation of objects that are stored in a knowledge graph. For examples, the user devices may create and edit documents that are stored in the knowledge graph as a node. The record of interactions, such as views, edits, may also be saved in the knowledge graph as edges. The devices may belong to many different users and a single user may use multiple devices.

Server 106 may comprise server-side software designed to work in conjunction with client-side software on user devices 102 a and 102 b through 102 n to implement any combination of the features and functionalities discussed in the present disclosure. For example, the server 106 may run the information management system 201, which manage access to and use of information in a knowledge graph. The server 106 may receive digital assets, such as files of documents, spreadsheets, emails, social media posts, user profiles, and the like for storage, from a large number of user devices belonging to many users. This division of operating environment 100 is provided to illustrate one example of a suitable environment, and there is no requirement for each implementation that any combination of server 106 and user devices 102 a and 102 b through 102 n remain as separate entities.

User devices 102 a and 102 b through 102 n may comprise any type of computing device capable of use by a user. For example, in one aspect, user devices 102 a through 102 n may be the type of computing device described in relation to FIG. 7 herein. By way of example and not limitation, a user device may be embodied as a personal computer (PC), a laptop computer, a mobile device, a smartphone, a tablet computer, a smart watch, a wearable computer, a fitness tracker, a virtual reality headset, augmented reality glasses, a personal digital assistant (PDA), an MP3 player, a global positioning system (GPS) or device, a video player, a handheld communications device, a gaming device or system, an entertainment system, a vehicle computer system, an embedded system controller, a remote control, an appliance, a consumer electronic device, a workstation, or any combination of these delineated devices, or any other suitable device.

Data sources 104 a and 104 b through 104 n may comprise data sources and/or data systems, which are configured to make data available to any of the various constituents of operating environment 100, or automated troubleshooting system 200 described in connection to FIG. 2 . For example, the data sources may comprise email servers, social media servers, or other sources of objects that may be stored in a knowledge graph managed by the technology described herein. Data sources 104 a and 104 b through 104 n may be discrete from user devices 102 a and 102 b through 102 n and server 106 or may be incorporated and/or integrated into at least one of those components.

Operating environment 100 may be utilized to implement one or more of the components of automated troubleshooting system 200, described in FIG. 2 , including components for collecting user data, defining visibility policies, receiving user queries related to an object property, responding to the query.

Referring now to FIG. 2 , with FIG. 1 , a block diagram is provided showing aspects of an example computing system architecture suitable for implementing some aspects of the present disclosure and designated generally as automated troubleshooting system 200. Automated troubleshooting system 200 represents only one example of a suitable computing system architecture. Other arrangements and elements may be used in addition to or instead of those shown, and some elements may be omitted altogether for the sake of clarity. Further, as with operating environment 100, many of the elements described herein are functional entities that may be implemented as discrete or distributed components or in conjunction with other components, and in any suitable combination and location.

Example automated troubleshooting system 200 includes troubleshooting guides 210, preprocessing component 220 (and its components 222, 224 and 226), segmentation component 230 (and its components 232 and 234), command identification component 240 (and its components 242, 244, and 246), command extraction component 250 (and its components 252 and 254), decision tree builder 260 (and its components 262 and 264), and workflow builder 270. These components may be embodied as a set of compiled computer instructions or functions, program modules, computer software services, or an arrangement of processes carried out on one or more computer systems, such as computing device 700 described in connection to FIG. 7 , for example.

In one aspect, the functions performed by components of automated troubleshooting system 200 are associated with one or more applications, services, or routines. In particular, such applications, services, or routines may operate on one or more user devices (such as user device 102 a), servers (such as server 106), may be distributed across one or more user devices and servers, or be implemented in the cloud. Moreover, in some aspects, these components of automated troubleshooting system 200 may be distributed across a network, including one or more servers (such as server 106) and client devices (such as user device 102 a), in the cloud, or may reside on a user device, such as user device 102 a. Moreover, these components, functions performed by these components, or services carried out by these components may be implemented at appropriate abstraction layer(s), such as the operating system layer, application layer, hardware layer, etc., of the computing system(s). Alternatively, or in addition, the functionality of these components and/or the aspects described herein may be performed, at least in part, by one or more hardware logic components. For example, and without limitation, illustrative types of hardware logic components that may be used include Field-programmable Gate Arrays (FPGAs), Application-specific Integrated Circuits (ASICs), Application-specific Standard Products (ASSPs), System-on-a-chip systems (SOCs), Complex Programmable Logic Devices (CPLDs), etc. Additionally, although functionality is described herein with reference to specific components shown in example automated troubleshooting system 200, it is contemplated that in some aspects functionality of these components may be shared or distributed across other components.

The trouble-shooting guides 210 are text documents that help a user identify and/or solve a problem. The automated workflow generation process described herein starts with existing TSGs 210 as the input. The technology described herein converts the TSG that is followed by human users to an automated workflow that can be executed by a computer. A single TSG may include troubleshooting instructions for a large number of problems. The TSGs can be in multiple formats, such as web pages, wikis, word processing documents, and the like.

The TSGs 210 may include combinations of textual explanations for users and computer commands (e.g., application commands) to be run as part of a workflow. The text may instruct the user to run the command and explain how the command works. The commands may perform a large number of different tasks, such as retrieving information used to identify a problem's cause or eliminate a potential cause. The commands in a TSG may be from different applications (e.g., PowerShell, SQL, Kusto, Scope, CosmosDB). Even a troubleshooting workflow for a single problem may include commands from several different applications. TSGs include a complex series of steps that may take the form of a decision tree to arrive at a solution. A complex TSG may include multiple paths that may be followed until the troubleshooting is complete. The application commands may have multiple components, such as commands, arguments, parameters, and attributes.

The preprocessing component 220 comprises common formatter 222, image converter 224 and text cleaner 226. The preprocessing component 220 processes the TSG 210 to build a preprocessed TSG 228 that can be operated on in a uniform way by the automated troubleshooting system 200. The preprocessing component 220 increases the robustness of the automated troubleshooting system 200 by allowing the system to build an automated workflow from TSGs that originate from many different platforms. Essentially, the preprocessing component 220 reduces formatting differences between TSGs and even TSG sections and allows subsequent components to work from a commonly formatted input.

The common formatter 222 converts TSGs into a common format, such as HTML (Hypertext Markup Language). Initially, the pre-existing TSGs can be drafted in a variety of forms, such as wikis, documents, PDFs, webpages, and the like. Many applications are presently available to convert content from one format to another.

The image converter 224 extracts text from an image and converts it to computer readable text. The image converter 224 uses optical character recognition (OCR) technology, such as found in the open-source Tesseract project. Tesseract provides an easy-to-use interface as well as an accompanying Python client library. The extracted text is added to the TSG as text in a standard format, such as HTML. The extracted text could include natural language text and/or application commands.

The text cleaner 226 cleans the text. For example, the text may be cleaned by removing HTML tags, decode Unicode characters, remove bold/italicize markers, strip extra whitespaces, fix inconsistencies in spellings, etc. The text cleaner 226 performs various tasks that remove noise from the text.

The text cleaner 226 can also perform tokenization and splitting. For example, the text cleaner can generate word or character tokens from the text. In one example, the text cleaner 226 performs stemming. In one aspect, stop words (e.g., the, is, at, and which) may be removed. The text cleaner can also identify white space, word, or sentence splits.

The segmentation component 230 comprises sentence identification component 232 and command boundary component 234. The segmentation component 230 receives the preprocessed TSG 228 and builds a segmented TSG 236. The TSG includes many lines or sentences. The sentence identification component 232 identifies sentences within the TSG and labels them. The command boundary component 234 may use the sentence label as an input when delimiting commands from natural language text. The sentence identification component 232 can be trained to recognize sentences in a TSG. As mentioned previously, the TSG may be converted to a common format, such as HTML. The HTML tags may be used in combination with NLP understanding to label sentences.

The command boundary component 234 labels commands within the TSG to delimit the command from surrounding text. The input to the command boundary component 234 may be TSG text with multiple commands and natural language sentences. At this point in the process, the commands and text are not separated from each other or labeled. The TSG may be entered into the command boundary component 234 as a series of word tokens and or character tokens (n-grams). As mentioned, the sentence identification component 232 may label sentences within the TSG text. The output from the command boundary component 234 may be TSG text with the start and end of command spans tagged using tags such as, <COMMAND_BEG> and <COMMAND_END>.

Manually written Troubleshooting guides often contain a multitude of application commands for different applications along with natural language statements explaining their use. Commands may run over multiple lines and different types of commands can occur consecutively in the TSG without natural language text separating the commands. Thus, statements need to be segmented accurately to correctly identify, parse, and create automatable workflows. Attempting to parse two commands at once will increase the probability of an error. Similarly, attempting to parse a mixture of natural language text and a command will also increase the error probability.

In one aspect, the command boundary component 234 comprises a sequence-to-sequence model. Sequence-to-sequence (often abbreviated to seq2seq) models are a special class of Recurrent Neural Network (RNN) architectures that may be used to solve complex language problems. In aspects, the RNN used by the command boundary component 234 may be a Long Short Term Memory network (LSTM), which is a special kind of RNN, capable of learning long-term dependencies.

The sequence-to-sequence model may comprise an embedding layer, an encoding layer, and a decoding layer. In aspects, the embedding layer is initiated with values from the trained embedding layer 310 from the twin neural network 242 used to classify commands. Using these values as a starting point conserves computer resources by reducing aspects of the model that need to be trained. In aspects, the twin neural network 242 and sequence-to-sequence model are both trained on TSGs with beginning and end of commands labeled. The sequence-to-sequence model may be trained to identify the start and end of a command by receiving commands and or commands within a TSG with the start and end labeled. Once the command is identified in the segmented TSG 236 as a command, rather than natural language text, then the application it is associated with may be identified.

The command identification component 240 identifies the application a command is associated with. In aspects, the command identification component 240 may use a metric-based meta-learning approach to associate a command with an application. The metric-based model calculates a metric or distance measure that can be used to determine similarity between commands. The meta-task can be—“Given a pair of commands, predict the probability that they belong to the same application.”

The command identification component 240 comprises a twin neural network 242, representation store 244, and similarity component 246. The command identification component 240 receives the segmented TSG 236 and builds a command labeled TSG. The command labeled TSG associates the application commands in the TSG with an application the command is associated with. The twin neural network 232 generates a representation of a command that can be used to generate a metric or distance between commands. The distance corresponds to similarity. The representation can be compared with representations of commands from a known application to generate a similarity score. The similarity score can be used to associate the unknown command with an application.

An exemplary architecture for a twin neural network 232 is illustrated to FIG. 3 . The twin neural network 232 (sometimes called a Siamese neural network) is an artificial neural network that uses two identical subnetworks. As used herein, “identical” means the two subnetworks (e.g., convolutional network A 312, and convolutional network B 314) have the same configuration with the same parameters and weights. Parameter updating is mirrored across both sub-networks during training. In aspects, the twin neural network 232 is trained using a few-shot approach that uses below a designated amount of training data per class (e.g., application to associated with a command). In aspects, the designated amount is less than 20, 15, 10, 8, 6, 4, 2 or 1 instance(s) of training data per class. In the case of a single training instance, the training could be described as one-shot learning.

The twin neural network 232 comprises a trainable embedding layer 310, convolutional network A 312, convolutional network B 314, and similarity component 230. The embedding layer 310 receives an input command 302 and generates an embedding (not shown) that is communicated to convolutional network A 312. When in operation, the input command 302 may be from a segmented TSG 236. The convolutional network A 312 generates an output 322, which may be described as a representation of the input command. The output 322 may be in the form of a vector and could be described as a feature vector.

The embedding layer 310 also receives input command 304 and generates an embedding (not shown) that is communicated to convolutional network B 314. When in operation mode (versus training mode), the input command 304 may be a labeled command from a known application (e.g., class). The convolutional network B 314 generates an output 324, which may be described as a representation of the input command. The output 324 may be in the form of a vector and may be described as a feature vector. In aspects, all of the training data (e.g., labeled commands) may be processed by the twin neural network 232 to generate representations of each training data instance. In aspects, multiple representations of commands from each application are generated and form class representations. The class representations may be stored in the representation store 234. In production mode, the similarity component 236 calculates a similarity score between a representation of an unlabeled command and each of the class representations. The unlabeled command may be classified as belonging to the application associated with the nearest (e.g., most similar) class representation.

In aspects, the similarity component 236 may use a Manhattan Distance measure. Manhattan distance is calculated as the sum of the absolute differences between the two vectors. In one aspect, the negative of the Manhattan distance metric is used to determine similarity. In other aspects, Euclidian distance, Minkowski Distance, or Euclidean Distance may be used. Additionally, other vector similarity measures may be used to assign an application to a command. The twin neural network 232 in combination with the similarity component 236 may is one example of a metric-based model. As used herein, a metric-based model generates an input representation and compares the input representation to other representations using a distance measure to assign a class to an input.

Training the twin neural network 232 comprises pairwise learning. Two labeled commands are input to the twin neural network 232 and two feature vectors are generated. In some instances, the two commands are from the same application. In other instances, the two commands are from the different applications. Commands from the same application should result in similar feature vectors. The goal is to train the twin neural network 232 to generate similar feature vectors when the commands are from the same application and different feature vectors when the commands are from different applications. In one aspect, the binary cross-entropy loss function is used during training. The binary cross-entropy loss function is a suitable choice for training because the classification is essentially binary (similar or dissimilar) to a known class of commands. Aspects of the invention are not limited to use of the binary cross-entropy loss function. In other aspects, contrastive function or triplet loss is used for training.

The embedding layer 310 turns the tokens from the input command into a mathematical representation (e.g., vector) that can be processed by the convolutional network. The embedding layer 310 may be trained to generate meaningful word and character embeddings using word2vec or some other method. The training of the embedding layer may use the corpus of labeled commands.

The command extraction component 250 comprises regular expression generator 252 and regular expression store 254. The command extraction component 250 receives the command labeled TSG 248 and builds an extracted TSG 256 with extracted commands and arguments.

A command may comprise multiple parts, such as command name, arguments, parameters, query attributes, flags, etc. These parts are parsed using regular expressions, which function as a type of query pattern to return the correct command part, such as command name. A regular expression (regex or regexp for short), is a special text string describing a search pattern. As previously noted, each command is now associated with an application in which the command may be used. The regular expressions may be specific to each application. For example, the command name may follow a different format in each application. In this case, a specific regular expression may be generated to parse the command name in each application.

As can be seen, generating the large number of regular expressions needed to parse a large number of application commands would be labor intensive, if done manually. The regular expression generator 252 uses program synthesis to generate regular expressions used in parsing commands. In one example, the MICROSOFT Prose tool is used to generate the regular expressions. Given a set of positive and negative examples of a command name, for example, the regular expression generator 252 automatically synthesizes the simplest possible regular expression that accepts all the positive examples while rejecting all the negative examples. The regular expressions can be generated based on a relatively small set of training data that includes labels for the parts of the command to be parsed by the expression being generated.

Once the regular expressions are generated, they can be stored in regular expression store 254. In addition to the automatically generated expressions, custom expressions can be stored. In order to extract, or parse, the command, the command extraction component 250 may execute all of the regular expressions and custom expressions associated with the application with which the command is associated. The result is a series of extracted commands and text within the TSG, which is described herein as an extracted TSG 256.

The decision tree builder 260 receives the extracted TSG 256 comprising extracted commands and arguments and builds a structured collection of steps 266. In one aspect, the structured collection of steps 266 may be an Extensible Markup Language (“XML”) or JSON document. As an initial step, the decision tree builder 260 identifies coherent sections in TSGs using a pretrained latent topic model and segments the document at topic shifts. Each topic may troubleshoot a single problem. A single decision tree may be built for each problem addressed within the TSG.

The latent topic model uncovers latent variables that govern the semantics of the TSG, these latent variables representing abstract topics. In one aspect, the latent topic model is a Latent Dirichlet Allocation (LDA) model, but other types of models are possible. In this implementation, the latent topic model does not require pre-training.

The step identification component 264 identifies complex flow of steps (e.g., Actions, Conditions, Iterations) using linguistic patterns and part-of-speech tags. Conditional expressions in TSGs are written in natural language. To create automated workflows, the technology described herein converts these statements to conditional expressions that can be evaluated programmatically. In this regard, the technology first extracts the left-hand side (LHS), right-hand side (RHS), operators, and combination of conditions. The technology makes use of Natural Language Processing to analyze subject and object noun phrases in sentences to identify LHS and RHS of a condition. The technology then identifies the operation by applying heuristics based on token meanings. For instance, “is consistent” would map to “,”. Finally, the technology constructs conditions and their combinations using conjunction tokens (from NLP) such as “OR” and “AND”.

TSGs may consist of multiple commands and conditional statements. They also contain multiple nested branches and sub-sections based on the result of these conditions. Typically, these conditions are dependent on the output of recently run commands in the TSG. Thus, it is important to link these conditions to the command of interest to create an automatable workflow. The technology described herein may use a Depth First Search (DFS) based Recursive algorithm for linking conditional statements derived from the natural language text to the command. Depth-first search is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking.

The process of building an ordered flow of steps may start with a command or conditional statement in the section and designates it the root node. The root node is the top node in the decision tree, which may be described as a stack. The process moves to a subsequent statement in the section, if the statement has been previously visited, then the process continues to the next statement. If not previously visited, the statement is then marked as visited. If the statement is a condition then the statement is linked to a command at the root level acting as a decision point with two or more possible branches to follow based on the outcome. If the statement is a command, then it is pushed to the stack at one level below the root. If the statement is a branch statement, then it is pushed to sublevel of the workflow.

The workflow builder 270 receives the structured collection of steps 266 and generates an automated workflow 272. As mentioned, the structured collection of steps 266 may be XML format. The automated workflow 272 may be a JSON file. Once the framework converts the TSG to a structured collection of steps (XML/JSON), the next step is to create an executable TSG.

Executable TSGs can be zero-touch specialized workflows executed in the cloud via custom infrastructure such as VMs or Serverless (like Azure Functions or AWS Lambda) OR they can also be web-based interactive computational workflows such as Jupyter notebooks. In both scenarios, the source document of the may be a structured JSON or XML, following a versioned schema, containing an ordered list of code (with corresponding meta-data such as type, command, arguments, etc.) and text blocks (with meta-data). This structured XML/JSON can be programmatically translated to the schema of the required executable. For instance, the text blocks would be translated to documentation and hints depending on the TSG, while the code block will be converted to the appropriate executable code by leveraging scripting languages like Python or specialized domain specific languages.

TSGs are typically executed manually in specific environments with certain permissions and connectors to services. These connections and kernels may be appended to the XML/JSON source document of the executable. Further corrections or changes may be made to the executable by humans to fix inaccuracies or add features. With this approach, a structured TSG (XML/JSON) is converted to an executable TSG (Notebooks/Workflows).

Exemplary Methods

Now referring to FIGS. 4-6 , each block of methods 400, 500, and 600, described herein, comprises a computing process that may be performed using any combination of hardware, firmware, and/or software. For instance, various functions may be carried out by a processor executing instructions stored in memory. The methods may also be embodied as computer-usable instructions stored on computer storage media. The method may be provided by a standalone application, a service or hosted service (standalone or in combination with another hosted service), or a plug-in to another product, to name a few. In addition, methods 400, 500, and 600 are described, by way of example, with respect to the automated troubleshooting system 200 of FIG. 2 and additional features of FIG. 3 . However, these methods may additionally or alternatively be executed by any one system, or any combination of systems, including, but not limited to, those described herein.

FIG. 4 is a flow diagram showing a method 400 for generating an automated troubleshooting guide (TSG), in accordance with some embodiments of the present disclosure. The trouble-shooting guides are text documents that help a user identify and/or solve a problem. The automated TSG generation process described herein starts with an existing TSG as the input. The technology described herein converts the TSG from a manual that is followed by human users to an automated TSG that can be executed by a computer and troubleshoot a problem without human intervention. A single TSG may include troubleshooting instructions for a large number of problems. The TSGs can be in multiple formats, such as web pages, wikis, word processing documents, and the like. Method 400 could be performed on or with systems similar to those described with reference to FIGS. 1, 2, and 3 .

The method 400, at block 410 includes identifying a starting point and an ending point for a computer command in a troubleshooting guide (TSG). The TSGs may include combinations of textual explanations for users and computer commands (e.g., application commands) to be run as part of a workflow. The text may instruct the user to run the command and explain how the command works. The commands may perform a large number of different tasks, such as retrieving information used to identify a problem's cause or eliminate a potential cause. The commands in a TSG may be from different applications (e.g., PowerShell, SQL, Kusto, Scope, CosmosDB). Even a troubleshooting workflow for a single problem may include commands from several different applications.

The output from step 410 may be TSG text with the start and end of command spans tagged using tags such as, <COMMAND_BEG> and <COMMAND_END>. Commands may run over multiple lines and different types of commands can occur consecutively in the TSG without natural language text separating the commands. Thus, statements need to be segmented accurately to correctly identify, parse, and create automatable workflows. Attempting to parse two commands at once will increase the probability of an error. Similarly, attempting to parse a mixture of natural language text and a command will also increase the error probability.

In one aspect, a sequence-to-sequence model is used to determine the boundaries. The sequence-to-sequence model may comprise an embedding layer, an encoding layer, and a decoding layer. The sequence-to-sequence model may be trained to identify the start and end of a command by receiving commands and or commands within a TSG with the start and end labeled.

The method 400, at block 420 includes classifying, with a metric-learning machine classifier, the computer command as belonging to a first application. The metric-based model calculates a metric or distance measure that can be used to determine similarity between commands. The meta-task may be—“Given a pair of commands, predict the probability that they belong to the same application.” The distance corresponds to similarity. The similarity score can be used to associate the unknown command with an application. In aspects, the similarity may be determined using a Manhattan Distance measure. Manhattan distance is calculated as the sum of the absolute differences between the two vectors. In one aspect, the negative of the Manhattan distance metric is used to determine similarity.

In one aspect, the metric learning model is a twin neural network, as described previously. Training the twin neural network comprises pairwise learning. Two labeled commands are input to the twin neural network and two feature vectors (e.g., representations) are generated. In some instances, the two commands are from the same application. In other instances, the two commands are from the different applications. Commands from the same application should result in similar feature vectors. The goal is to train the twin neural network to generate similar feature vectors when the commands are from the same application and different feature vectors when the commands are from different applications. In one aspect, the binary cross-entropy loss function is used during training. The binary cross-entropy loss function is a suitable choice for training because the classification is essentially binary (similar or dissimilar) to a known class of commands. Aspects of the invention are not limited to use of the binary cross-entropy loss function. In other aspects, contrastive function or triplet loss is used for training.

The method 400, at block 430 includes extracting sub-components of the computer command with a regular expression that is specific to the first application. A command may comprise multiple parts, such as command name, arguments, parameters, query attributes, flags, etc. These parts may be parsed using regular expressions, which function as a type of query pattern to return the correct command part, such as command name. A regular expression (regex or regexp for short), is a special text string describing a search pattern.

Generating the large number of regular expressions needed to parse a large number of application commands would be labor intensive, if done manually. The regular expression generator 252 uses program synthesis to generate regular expressions used in parsing commands. In one example, the MICROSOFT Prose tool is used to generate the regular expressions. Given a set of positive and negative examples of a command name, for example, the regular expression generator 252 automatically synthesizes the simplest possible regular expression that accepts all the positive examples while rejecting all the negative examples. The regular expressions can be generated based on a relatively small set of training data that includes labels for the parts of the command to be parsed by the expression being generated.

Once the regular expressions are generated, they can be stored. In addition to the automatically generated expressions, custom expressions can be stored. In order to extract, or parse, the command, the regular expressions and custom expressions associated with the application with which the command is associated are executed. The result is a series of extracted commands and text within the TSG.

The method 400, at block 440 includes building a structured collection of steps associated with troubleshooting a single problem. The structured collection is built from a natural language text adjacent to the computer command within the TSG and the computer command itself. TSGs include a complex series of steps that may take the form of a decision tree to arrive at a solution. A complex TSG may include multiple paths that may be followed until the troubleshooting is complete. The application commands may have multiple components, such as commands, arguments, parameters, and attributes.

TSGs may consist of multiple commands and conditional statements. They also contain multiple nested branches and sub-sections based on the result of these conditions. Typically, these conditions are dependent on the output of recently run commands in the TSG. Thus, it is important to link these conditions to the command of interest to create an automatable workflow. The technology described herein may use a Depth First Search (DFS) based Recursive algorithm for linking conditional statements derived from the natural language text to the command. Depth-first search is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking.

The process of building an ordered flow of steps may start with a command or conditional statement in the section and designates it the root node. The root node is the top node in the decision tree, which may be described as a stack. The process moves to a subsequent statement in the section, if the statement has been previously visited, then the process continues to the next statement. If not previously visited, the statement is then marked as visited. If the statement is a condition then the statement is linked to a command at the root level acting as a decision point with two or more possible branches to follow based on the outcome. If the statement is a command, then it is pushed to the stack at one level below the root. If the statement is a branch statement, then it is pushed to sublevel of the workflow.

The method 400, at block 450 includes converting the structured collection of steps into an automated workflow configured to troubleshoot the single problem when executed by a computing system.

FIG. 5 is a flow diagram showing a method 500 for generating an automated troubleshooting guide (TSG), in accordance with some embodiments of the present disclosure. The method 500, at block 510 includes identifying a starting point and an ending point for a computer command in a troubleshooting guide (TSG) using a sequence-to-sequence based model. The output from step 410 may be TSG text with the start and end of command spans tagged using tags such as, <COMMAND_BEG> and <COMMAND_END>. Commands may run over multiple lines and different types of commands can occur consecutively in the TSG without natural language text separating the commands. Thus, statements need to be segmented accurately to correctly identify, parse, and create automatable workflows. Attempting to parse two commands at once will increase the probability of an error. Similarly, attempting to parse a mixture of natural language text and a command will also increase the error probability.

Sequence-to-sequence (often abbreviated to seq2seq) models are a special class of Recurrent Neural Network (RNN) architectures that may be used to solve complex language problems. In aspects, the RNN used by the command boundary component 234 may be a Long Short Term Memory network (LSTM), which is a special kind of RNN, capable of learning long-term dependencies.

The sequence-to-sequence model may comprise an embedding layer, an encoding layer, and a decoding layer. In aspects, the embedding layer is initiated with values from the trained embedding layer from the twin neural network used to classify commands in step 520. Using these values as a starting point conserves computer resources by reducing aspects of the model that need to be trained. In aspects, the twin neural network and sequence-to-sequence model are both trained on TSGs with beginning and end of commands labeled. The sequence-to-sequence model may be trained to identify the start and end of a command by receiving commands and or commands within a TSG with the start and end labeled.

The method 500, at block 520 includes classifying the computer command as belonging to a first application. The classification may be performed by a metric-based model. The metric-based model calculates a metric or distance measure that can be used to determine similarity between commands. The meta-task may be—“Given a pair of commands, predict the probability that they belong to the same application.” The distance corresponds to similarity. The similarity score can be used to associate the unknown command with an application. In aspects, the similarity may be determined using a Manhattan Distance measure. Manhattan distance is calculated as the sum of the absolute differences between the two vectors. In one aspect, the negative of the Manhattan distance metric is used to determine similarity.

In one aspect, the metric learning model is a twin neural network, as described previously. Training the twin neural network comprises pairwise learning. Two labeled commands are input to the twin neural network and two feature vectors (e.g., representations) are generated. In some instances, the two commands are from the same application. In other instances, the two commands are from the different applications. Commands from the same application should result in similar feature vectors. The goal is to train the twin neural network to generate similar feature vectors when the commands are from the same application and different feature vectors when the commands are from different applications. In one aspect, the binary cross-entropy loss function is used during training. The binary cross-entropy loss function is a suitable choice for training because the classification is essentially binary (similar or dissimilar) to a known class of commands. Aspects of the invention are not limited to use of the binary cross-entropy loss function. In other aspects, contrastive function or triplet loss is used for training.

The method 500, at block 530 includes extracting sub-components of the computer command with a regular expression that is specific to the first application. The regular expression may be generated through a program synthesis. A command may comprise multiple parts, such as command name, arguments, parameters, query attributes, flags, etc. These parts may be parsed using regular expressions, which function as a type of query pattern to return the correct command part, such as command name. A regular expression (regex or regexp for short), is a special text string describing a search pattern.

Generating the large number of regular expressions needed to parse a large number of application commands would be labor intensive, if done manually. The regular expression generator 252 uses program synthesis to generate regular expressions used in parsing commands. In one example, the MICROSOFT Prose tool is used to generate the regular expressions. Given a set of positive and negative examples of a command name, for example, the regular expression generator 252 automatically synthesizes the simplest possible regular expression that accepts all the positive examples while rejecting all the negative examples. The regular expressions can be generated based on a relatively small set of training data that includes labels for the parts of the command to be parsed by the expression being generated.

Once the regular expressions are generated, they can be stored. In addition to the automatically generated expressions, custom expressions can be stored. In order to extract, or parse, the command, the regular expressions and custom expressions associated with the application with which the command is associated are executed. The result is a series of extracted commands and text within the TSG.

The method 500, at block 540 includes translating conditional natural language statements within a natural language text, which is adjacent to the computer command within the TSG, into logical structures with a program synthesis. To create automated workflows, the technology described herein converts these statements to conditional expressions that can be evaluated programmatically. In this regard, the technology first extracts the left-hand side (LHS), right-hand side (RHS), operators, and combination of conditions. The technology makes use of Natural Language Processing to analyze subject and object noun phrases in sentences to identify LHS and RHS of a condition. The technology then identifies the operation by applying heuristics based on token meanings. For instance, “is consistent” would map to “,”. Finally, the technology constructs conditions and their combinations using conjunction tokens (from NLP) such as “OR” and “AND”.

The method 500, at block 550 includes building from the natural language text and the computer command a structured collection of steps associated with troubleshooting a single problem. TSGs may consist of multiple commands and conditional statements. They also contain multiple nested branches and sub-sections based on the result of these conditions. Typically, these conditions are dependent on the output of recently run commands in the TSG. Thus, it is important to link these conditions to the command of interest to create an automatable workflow. The technology described herein may use a Depth First Search (DFS) based Recursive algorithm for linking conditional statements derived from the natural language text to the command. Depth-first search is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking.

The process of building an ordered flow of steps may start with a command or conditional statement in the section and designates it the root node. The root node is the top node in the decision tree, which may be described as a stack. The process moves to a subsequent statement in the section, if the statement has been previously visited, then the process continues to the next statement. If not previously visited, the statement is then marked as visited. If the statement is a condition then the statement is linked to a command at the root level acting as a decision point with two or more possible branches to follow based on the outcome. If the statement is a command, then it is pushed to the stack at one level below the root. If the statement is a branch statement, then it is pushed to sublevel of the workflow.

The method 500, at block 560 includes converting the structured collection of steps into an automated workflow configured to troubleshoot the single problem when executed by a computing system.

FIG. 6 is a flow diagram showing a method 600 for generating an automated troubleshooting guide (TSG), in accordance with some embodiments of the present disclosure.

The method 600, at block 610 includes identifying, with a first machine-learning model, a computer command in a troubleshooting guide (TSG), the first machine-learning model comprising an embedding layer initiated with values from a trained embedding layer from a second machine-learning model.

The method 600, at block 620 includes classifying, with the second machine-learning model, the computer command as belonging to a first application. The second machine-learning model may be a metric-based model. The metric-based model calculates a metric or distance measure that can be used to determine similarity between commands. The meta-task may be—“Given a pair of commands, predict the probability that they belong to the same application.” The distance corresponds to similarity. The similarity score can be used to associate the unknown command with an application. In aspects, the similarity may be determined using a Manhattan Distance measure. Manhattan distance is calculated as the sum of the absolute differences between the two vectors. In one aspect, the negative of the Manhattan distance metric is used to determine similarity.

In one aspect, the metric learning model is a twin neural network, as described previously. Training the twin neural network comprises pairwise learning. Two labeled commands are input to the twin neural network and two feature vectors (e.g., representations) are generated. In some instances, the two commands are from the same application. In other instances, the two commands are from the different applications. Commands from the same application should result in similar feature vectors. The goal is to train the twin neural network to generate similar feature vectors when the commands are from the same application and different feature vectors when the commands are from different applications. In one aspect, the binary cross-entropy loss function is used during training. The binary cross-entropy loss function is a suitable choice for training because the classification is essentially binary (similar or dissimilar) to a known class of commands. Aspects of the invention are not limited to use of the binary cross-entropy loss function. In other aspects, contrastive function or triplet loss is used for training.

The method 600, at block 630 includes extracting sub-components of the computer command with a regular expression that is specific to the first application. A command may comprise multiple parts, such as command name, arguments, parameters, query attributes, flags, etc. These parts may be parsed using regular expressions, which function as a type of query pattern to return the correct command part, such as command name. A regular expression (regex or regexp for short), is a special text string describing a search pattern.

Generating the large number of regular expressions needed to parse a large number of application commands would be labor intensive, if done manually. The regular expression generator 252 uses program synthesis to generate regular expressions used in parsing commands. In one example, the MICROSOFT Prose tool is used to generate the regular expressions. Given a set of positive and negative examples of a command name, for example, the regular expression generator 252 automatically synthesizes the simplest possible regular expression that accepts all the positive examples while rejecting all the negative examples. The regular expressions can be generated based on a relatively small set of training data that includes labels for the parts of the command to be parsed by the expression being generated.

Once the regular expressions are generated, they can be stored. In addition to the automatically generated expressions, custom expressions can be stored. In order to extract, or parse, the command, the regular expressions and custom expressions associated with the application with which the command is associated are executed. The result is a series of extracted commands and text within the TSG.

The method 600, at block 640 includes building a structured collection of steps associated with troubleshooting a single problem. The structured collection is built from a natural language text adjacent to the computer command within the TSG and the computer command itself. TSGs may consist of multiple commands and conditional statements. They also contain multiple nested branches and sub-sections based on the result of these conditions. Typically, these conditions are dependent on the output of recently run commands in the TSG. Thus, it is important to link these conditions to the command of interest to create an automatable workflow. The technology described herein may use a Depth First Search (DFS) based Recursive algorithm for linking conditional statements derived from the natural language text to the command. Depth-first search is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking.

The process of building an ordered flow of steps may start with a command or conditional statement in the section and designates it the root node. The root node is the top node in the decision tree, which may be described as a stack. The process moves to a subsequent statement in the section, if the statement has been previously visited, then the process continues to the next statement. If not previously visited, the statement is then marked as visited. If the statement is a condition then the statement is linked to a command at the root level acting as a decision point with two or more possible branches to follow based on the outcome. If the statement is a command, then it is pushed to the stack at one level below the root. If the statement is a branch statement, then it is pushed to sublevel of the workflow.

The method 600, at block 650 includes converting the structured collection of steps into an automated workflow configured to troubleshoot the single problem when executed by a computing system.

The method 600, at block 660 includes, without human intervention, troubleshooting an occurrence of the single problem with the automated workflow. Without human intervention may include a human identifying the problem and initiating the automated workflow.

Exemplary Operating Environment

Referring to the drawings in general, and initially to FIG. 7 in particular, an exemplary operating environment for implementing aspects of the technology described herein is shown and designated generally as computing device 700. Computing device 700 is but one example of a suitable computing environment and is not intended to suggest any limitation as to the scope of use of the technology described herein. Neither should the computing device 700 be interpreted as having any dependency or requirement relating to any one or combination of components illustrated.

The technology described herein may be described in the general context of computer code or machine-useable instructions, including computer-executable instructions such as program components, being executed by a computer or other machine, such as a personal data assistant or other handheld device. Generally, program components, including routines, programs, objects, components, data structures, and the like, refer to code that performs particular tasks or implements particular abstract data types. The technology described herein may be practiced in a variety of system configurations, including handheld devices, consumer electronics, general-purpose computers, specialty computing devices, etc. Aspects of the technology described herein may also be practiced in distributed computing environments where tasks are performed by remote-processing devices that are linked through a communications network.

With continued reference to FIG. 7 , computing device 700 includes a bus 710 that directly or indirectly couples the following devices: memory 712, one or more processors 714, one or more presentation components 716, input/output (I/O) ports 718, I/O components 720, and an illustrative power supply 722. Bus 710 represents what may be one or more busses (such as an address bus, data bus, or a combination thereof). Although the various blocks of FIG. 7 are shown with lines for the sake of clarity, in reality, delineating various components is not so clear, and metaphorically, the lines would more accurately be grey and fuzzy. For example, one may consider a presentation component such as a display device to be an I/O component. Also, processors have memory. The inventors hereof recognize that such is the nature of the art and reiterate that the diagram of FIG. 7 is merely illustrative of an exemplary computing device that may be used in connection with one or more aspects of the technology described herein. Distinction is not made between such categories as “workstation,” “server,” “laptop,” “handheld device,” etc., as all are contemplated within the scope of FIG. 7 and refer to “computer” or “computing device.”

Computing device 700 typically includes a variety of computer-readable media. Computer-readable media may be any available media that may be accessed by computing device 700 and includes both volatile and nonvolatile, removable and non-removable media. By way of example, and not limitation, computer-readable media may comprise computer storage media and communication media. Computer storage media includes both volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer-readable instructions, data structures, program modules, or other data.

Computer storage media includes RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices. Computer storage media does not comprise a propagated data signal.

Communication media typically embodies computer-readable instructions, data structures, program modules, or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared, and other wireless media. Combinations of any of the above should also be included within the scope of computer-readable media.

Memory 712 includes computer storage media in the form of volatile and/or nonvolatile memory. The memory 712 may be removable, non-removable, or a combination thereof. Exemplary memory includes solid-state memory, hard drives, optical-disc drives, etc. Computing device 700 includes one or more processors 714 that read data from various entities such as bus 710, memory 712, or I/O components 720. Presentation component(s) 716 present data indications to a user or other device. Exemplary presentation components 716 include a display device, speaker, printing component, vibrating component, etc. I/O ports 718 allow computing device 700 to be logically coupled to other devices, including I/O components 720, some of which may be built in.

Illustrative I/O components include a microphone, joystick, game pad, satellite dish, scanner, printer, display device, wireless device, a controller (such as a stylus, a keyboard, and a mouse), a natural user interface (NUI), and the like. In aspects, a pen digitizer (not shown) and accompanying input instrument (also not shown but which may include, by way of example only, a pen or a stylus) are provided in order to digitally capture freehand user input. The connection between the pen digitizer and processor(s) 714 may be direct or via a coupling utilizing a serial port, parallel port, and/or other interface and/or system bus known in the art. Furthermore, the digitizer input component may be a component separated from an output component such as a display device, or in some aspects, the usable input area of a digitizer may coexist with the display area of a display device, be integrated with the display device, or may exist as a separate device overlaying or otherwise appended to a display device. Any and all such variations, and any combination thereof, are contemplated to be within the scope of aspects of the technology described herein.

An NUI processes air gestures, voice, or other physiological inputs generated by a user. Appropriate NUI inputs may be interpreted as ink strokes for presentation in association with the computing device 700. These requests may be transmitted to the appropriate network element for further processing. An NUI implements any combination of speech recognition, touch and stylus recognition, facial recognition, biometric recognition, gesture recognition both on screen and adjacent to the screen, air gestures, head and eye tracking, and touch recognition associated with displays on the computing device 700. The computing device 700 may be equipped with depth cameras, such as stereoscopic camera systems, infrared camera systems, RGB camera systems, and combinations of these, for gesture detection and recognition. Additionally, the computing device 700 may be equipped with accelerometers or gyroscopes that enable detection of motion. The output of the accelerometers or gyroscopes may be provided to the display of the computing device 700 to render immersive augmented reality or virtual reality.

A computing device may include a radio 724. The radio 724 transmits and receives radio communications. The computing device may be a wireless terminal adapted to receive communications and media over various wireless networks. Computing device 700 may communicate via wireless policies, such as code division multiple access (“CDMA”), global system for mobiles (“GSM”), or time division multiple access (“TDMA”), as well as others, to communicate with other devices. The radio communications may be a short-range connection, a long-range connection, or a combination of both a short-range and a long-range wireless telecommunications connection. When we refer to “short” and “long” types of connections, we do not mean to refer to the spatial relation between two devices. Instead, we are generally referring to short range and long range as different categories, or types, of connections (i.e., a primary connection and a secondary connection). A short-range connection may include a Wi-Fi® connection to a device (e.g., mobile hotspot) that provides access to a wireless communications network, such as a WLAN connection using the 802.11 protocol. A Bluetooth connection to another computing device is a second example of a short-range connection. A long-range connection may include a connection using one or more of CDMA, GPRS, GSM, TDMA, and 802.16 policies.

EMBODIMENTS

EMBODIMENT 1. One or more computer storage media comprising computer-executable instructions that when executed by a computing device cause the computing device to perform a method of generating an automated troubleshooting guide (TSG). The method comprises identifying a starting point and an ending point for a computer command in a troubleshooting guide (TSG). The method also comprises classifying, with a metric-learning machine classifier, the computer command as belonging to a first application. The method also comprises extracting sub-components of the computer command with a regular expression that is specific to the first application. The method also comprises building a structured collection of steps associated with troubleshooting a single problem, the structured collection built from the computer command and a natural language text adjacent to the computer command within the TSG. The method also comprises converting the structured collection of steps into an automated workflow configured to troubleshoot the single problem when executed by a computing system.

The use of a metric-based meta-learning can be trained for this task using a minimum amount training data, such as only one training example (one-shot) per application of origin. The use of a metric-based meta-learning can save computer resources by minimizing training iterations. The metric-based meta-learning also minimizes resources needed to collect and build training data examples.

EMBODIMENT 2. The media of embodiment 1, wherein the classifying, with the metric-learning machine classifier, the computer command as belonging to the first application, further comprises inputting the computer command to a neural network. The method also comprises receiving a first representation of the computer command from the neural network. The method also comprises determining from a distance metric that the first representation is most similar to a second representation of a command belonging to the first application.

EMBODIMENT 3. The media of embodiment 2, wherein the neural network is a twin neural network.

EMBODIMENT 4. The media as in any one of embodiments 1 and 2, wherein the distance metric is generated using a Manhattan distance measure.

EMBODIMENT 5. The media as in any one of the preceding embodiments, further comprising translating conditional natural language statements within the natural language text into logical structures with program synthesis.

EMBODIMENT 6. The media as in any one of the preceding embodiments, wherein the sub-components are selected from a group consisting of commands, arguments, parameters, and attributes.

EMBODIMENT 7. The media as in any one of the preceding embodiments, wherein the regular expression is generated using programming by example.

EMBODIMENT 8. A computer-implemented method of generating an automated troubleshooting guide (TSG). The method comprises identifying a starting point and an ending point for a computer command in a troubleshooting guide (TSG) using a sequence-to-sequence based model. The method also comprises classifying the computer command as belonging to a first application. The method also comprises extracting sub-components of the computer command with a regular expression that is specific to the first application. The method also comprises translating conditional natural language statements within a natural language text, which is adjacent to the computer command within the TSG, into logical structures with a first program synthesis. The method also comprises building from the natural language text and the computer command a structured collection of steps associated with troubleshooting a single problem. The method also comprises converting the structured collection of steps into an automated workflow configured to troubleshoot the single problem when executed by a computing system.

As can be seen, generating the large number of regular expressions needed to parse a large number of application commands would be labor intensive, if done manually. Program synthesis may be used to generate regular expressions used in parsing commands. The use of program synthesis to generate regular expressions can save considerable time and resources compared to other methods.

In one aspect, training efficiency may be achieved by using transfer learning when training the model. In particular, an embedding layer may be initiated with values from the trained embedding layer from the separate model used to classify commands by application of origin. Using these values as a starting point conserves computer resources by reducing aspects of the model that need to be trained

EMBODIMENT 9. The method as in any one of the preceding embodiments, wherein the classifying is with a metric-learning machine classifier and further comprises inputting the computer command to a neural network. The method also comprises receiving a first representation of the computer command from the neural network. The method also comprises determining from a distance metric that the first representation is most similar to a second representation of a command belonging to the first application.

EMBODIMENT 10. The method as in any one of the preceding embodiments, wherein the neural network is a twin neural network.

EMBODIMENT 11. The method as in any one of the preceding embodiments, wherein a trained embedding layer from the neural network is used with the sequence-to-sequence based model.

EMBODIMENT 12. The method of embodiment 11, wherein the trained embedding layer is tuned during training of the sequence-to-sequence based model.

EMBODIMENT 13. The method as in any one of the preceding embodiments, further comprising, without human intervention, troubleshooting an occurrence of the single problem with the automated workflow.

EMBODIMENT 14. The method as in any one of the preceding embodiments, wherein a depth-first search is used to build the structured collection of steps.

EMBODIMENT 15. The method as in any one of the preceding embodiments, wherein the method further comprises generating the regular expression through a second program synthesis.

EMBODIMENT 16. A system comprising one or more processors and one or more computer storage media storing computer-useable instructions that, when used by the one or more processors, cause the one or more processors to perform a method. The method comprising identifying, with a first machine-learning model, a computer command in a troubleshooting guide (TSG), the first machine-learning model comprising an embedding layer initiated with values from a trained embedding layer from a second machine-learning model. The method also comprises classifying, with the second machine-learning model, the computer command as belonging to a first application. The method also comprises extracting sub-components of the computer command with a regular expression that is specific to the first application. The method also comprises building a structured collection of steps associated with troubleshooting a single problem, the structured collection of steps built from the computer command and a natural language text adjacent to the computer command within the TSG. The method also comprises converting the structured collection of steps into an automated workflow configured to troubleshoot the single problem when executed by a computing system. The method also comprises without human intervention, troubleshooting an occurrence of the single problem with the automated workflow.

EMBODIMENT 17. The system of embodiment 16, wherein the first machine-learning model is a sequence-to-sequence based model. In one aspect, training efficiency may be achieved by using transfer learning when training the model. In particular, an embedding layer may be initiated with values from the trained embedding layer from the separate model used to classify commands by application of origin. Using these values as a starting point conserves computer resources by reducing aspects of the model that need to be trained.

EMBODIMENT 18. The system as in any one of the preceding embodiments, wherein a depth-first search is used to build the structured collection of steps.

EMBODIMENT 19. The system of embodiment 16, wherein the second machine-learning model is a metric-learning machine classifier. The use of a metric-based meta-learning can be trained for this task using a minimum amount training data, such as only one training example (one-shot) per application of origin. The use of a metric-based meta-learning can save computer resources by minimizing training iterations. The metric-based meta-learning also minimizes resources needed to collect and build training data examples.

EMBODIMENT 20. The system of embodiment 19, wherein the classifying with the second machine-learning model further comprises inputting the computer command to a neural network. The method also comprises receiving a first representation of the computer command from the neural network. The method also comprises determining from a distance metric that the first representation is most similar to a second representation of a command belonging to the first application.

The technology described herein has been described in relation to particular aspects, which are intended in all respects to be illustrative rather than restrictive. While the technology described herein is susceptible to various modifications and alternative constructions, certain illustrated aspects thereof are shown in the drawings and have been described above in detail. It should be understood, however, that there is no intention to limit the technology described herein to the specific forms disclosed, but on the contrary, the intention is to cover all modifications, alternative constructions, and equivalents falling within the spirit and scope of the technology described herein. 

What is claimed is:
 1. One or more computer storage media comprising computer-executable instructions that when executed by a computing device cause the computing device to perform a method of generating an automated troubleshooting guide (TSG), comprising: identifying a starting point and an ending point for a computer command in a troubleshooting guide (TSG); classifying, with a metric-learning machine classifier, the computer command as belonging to a first application; extracting sub-components of the computer command with a regular expression that is specific to the first application; building a structured collection of steps associated with troubleshooting a single problem, the structured collection built from the computer command and a natural language text adjacent to the computer command within the TSG; and converting the structured collection of steps into an automated workflow configured to troubleshoot the single problem when executed by a computing system.
 2. The media of claim 1, wherein the classifying, with the metric-learning machine classifier, the computer command as belonging to the first application, further comprises: inputting the computer command to a neural network; receiving a first representation of the computer command from the neural network; and determining from a distance metric that the first representation is most similar to a second representation of a command belonging to the first application.
 3. The media of claim 2, wherein the neural network is a twin neural network.
 4. The media of claim 2, wherein the distance metric is generated using a Manhattan distance measure.
 5. The media of claim 1, further comprising translating conditional natural language statements within the natural language text into logical structures with program synthesis.
 6. The media of claim 1, wherein the sub-components are selected from a group consisting of commands, arguments, parameters, and attributes.
 7. The media of claim 1, wherein the regular expression is generated using programming by example.
 8. A computer-implemented method of generating an automated troubleshooting guide (TSG), comprising: identifying a starting point and an ending point for a computer command in a troubleshooting guide (TSG) using a sequence-to-sequence based model; classifying the computer command as belonging to a first application; extracting sub-components of the computer command with a regular expression that is specific to the first application; translating conditional natural language statements within a natural language text, which is adjacent to the computer command within the TSG, into logical structures with a first program synthesis; building from the natural language text and the computer command a structured collection of steps associated with troubleshooting a single problem; and converting the structured collection of steps into an automated workflow configured to troubleshoot the single problem when executed by a computing system.
 9. The method of claim 8, wherein the classifying is with a metric-learning machine classifier and further comprises: inputting the computer command to a neural network; receiving a first representation of the computer command from the neural network; and determining from a distance metric that the first representation is most similar to a second representation of a command belonging to the first application.
 10. The method of claim 9, wherein the neural network is a twin neural network.
 11. The method of claim 9, wherein a trained embedding layer from the neural network is used with the sequence-to-sequence based model.
 12. The method of claim 11, wherein the trained embedding layer is tuned during training of the sequence-to-sequence based model.
 13. The method of claim 8, further comprising, without human intervention, troubleshooting an occurrence of the single problem with the automated workflow.
 14. The method of claim 8, wherein a depth-first search is used to build the structured collection of steps.
 15. The method of claim 8, wherein the method further comprises generating the regular expression through a second program synthesis.
 16. A system comprising: one or more processors; and one or more computer storage media storing computer-useable instructions that, when used by the one or more processors, cause the one or more processors to perform a method, the method comprising: identifying, with a first machine-learning model, a computer command in a troubleshooting guide (TSG), the first machine-learning model comprising an embedding layer initiated with values from a trained embedding layer from a second machine-learning model; classifying, with the second machine-learning model, the computer command as belonging to a first application; extracting sub-components of the computer command with a regular expression that is specific to the first application; building a structured collection of steps associated with troubleshooting a single problem, the structured collection of steps built from the computer command and a natural language text adjacent to the computer command within the TSG; converting the structured collection of steps into an automated workflow configured to troubleshoot the single problem when executed by a computing system; and without human intervention, troubleshooting an occurrence of the single problem with the automated workflow.
 17. The system of claim 16, wherein the first machine-learning model is a sequence-to-sequence based model.
 18. The system of claim 16, wherein a depth-first search is used to build the structured collection of steps.
 19. The system of claim 16, wherein the second machine-learning model is a metric-learning machine classifier.
 20. The system of claim 19, wherein the classifying with the second machine-learning model further comprises: inputting the computer command to a neural network; receiving a first representation of the computer command from the neural network; and determining from a distance metric that the first representation is most similar to a second representation of a command belonging to the first application. 